#define quickread
#ifdef quickread
#include <cstdio> 
template <typename T>
inline void read(T& x)
{
    int c=getchar(), f=1; x=0;
    while(c<'0'||'9'<c) {if(c=='-') f=-1; c=getchar();}
    while('0'<=c&&c<='9') 
        x=(x<<3)+(x<<1)+c-'0', c=getchar();
    x*=f;
}
template <typename T>
inline void quickwrite(T x)
{
    if(x<0) putchar('-'), x*=-1;
    if(x>=10) quickwrite(x/10);
    putchar(x%10+'0');
}
#else 
#include <iostream>
#endif
#include <cstring>
#include <algorithm>
using namespace std;
#define DEBUG
const int N=12010, M=N*3;

int n, m, Q, new_n; //方点
int h1[N], h2[N], w[M], e[M], ne[M], idx;
int dfn[N], low[N], cnt; //dfs序 最早能回溯到的祖先节点访问顺序
int s[N], stot[N], fu[N], fw[N], fe[N];
/*  环上节点到环上某一点的距离
    环上节点到环上起点的总距离
    父节点
    父节点到当前节点的边权
    节点从哪条边来的
*/
int fa[N][14]; //倍增法求lca
int depth[N], dist[N]; //节点深度 从根节点到当前节点的距离
int A, B;

void AddEdge(int h[], int a, int b, int c)
{
    e[idx]=b, w[idx]=c, ne[idx]=h[a], h[a]=idx++; 
}
int lca(int a, int b)
{
    if(depth[a]<depth[b]) swap(a, b);
    for(int k=13; k>=0; k--)
        if(depth[fa[a][k]]>=depth[b])
            a=fa[a][k];
    if(a==b) return a;
    for(int k=13; k>=0; k--)
        if(fa[a][k]!=fa[b][k])
            a=fa[a][k], b=fa[b][k];
    A=a, B=b;
    return fa[a][0]; //返回当前a的父节点
}

//重新构建环在新图的连接方式
void build_circle(int x, int y, int z)
{
    int sum=z;
    for(int k=y; k!=x; k=fu[k])
        s[k]=sum, sum+=fw[k]; //计算环上节点到环上某一点的距离
    s[x]=stot[x]=sum;
    AddEdge(h2, x, ++new_n, 0); //添加一个新的虚拟节点
    for(int k=y; k!=x; k=fu[k])
    {
        stot[k]=sum;
        AddEdge(h2, new_n, k, min(s[k], sum-s[k])); //边权为该节点到环上起点的最短路径距离
    }
}

//搜换，把不在环上的边加到新图h2中
void Tarjan(int u, int from) //当前遍历到那个点 从哪条边来的
{
    dfn[u]=low[u]=++cnt;
    for(int i=h1[u]; ~i; i=ne[i])
    {
        int v=e[i];
        if(!dfn[v])
        {
            fu[v]=u, fw[v]=w[i], fe[v]=i; //父节点 父节点到当前节点的边权 从哪条边来的
            Tarjan(v, i);
            low[u]=min(low[u], low[v]); //v可能回溯上去
            if(dfn[u]<low[v]) AddEdge(h2, u, v, w[i]);
        }
        else if(i!=(from^1)) low[u]=min(low[u], dfn[v]);
    }

    for(int i=h1[u]; ~i; i=ne[i])
    {
        int v=e[i];
        if(dfn[u]<dfn[v]&&fe[v]!=i)
            build_circle(u, v, w[i]);
    }
}   

//树上倍增预处理
void dfs_lca(int u, int father)
{
    depth[u]=depth[father]+1;
    fa[u][0]=father;
    for(int k=1; k<=13; k++)
        fa[u][k]=fa[fa[u][k-1]][k-1];
    for(int i=h2[u]; ~i; i=ne[i])
    {
        int v=e[i];
        dist[v]=dist[u]+w[i];
        dfs_lca(v, u);
    }
}

void init()
{
    read(n), read(m), read(Q);
    new_n=n;
    memset(h1, -1, sizeof h1);
    memset(h2, -1, sizeof h2);
    while(m--)
    {
        int a, b, c; read(a), read(b), read(c);
        AddEdge(h1, a, b, c); AddEdge(h1, b, a, c);
    }
}

void solve()
{
    init();

    Tarjan(1, -1);
    dfs_lca(1, 0);
    while(Q--)
    {
        // printf("Q=%d\n", Q);
        int a, b;
        read(a), read(b);
        int pa=lca(a, b);
        //原图节点
        if(pa<=n) quickwrite(dist[a]+dist[b]-(dist[pa]<<1)), puts("");
        else//虚拟节点->环内两点
        {
            int da=dist[a]-dist[A], db=dist[b]-dist[B];
            int l=abs(s[A]-s[B]);
            int dm=min(l, stot[A]-l);
            quickwrite(da+dm+db), puts("");
        }
    }
}

// #undef DEBUG
signed main()
{
    #ifdef DEBUG
        freopen("./in.txt", "r", stdin);
        freopen("./out.txt", "w", stdout);
    #endif
    #ifndef quickread
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    #endif

    int T=1; //scanf("%d", &T);
    while(T--) 
    {
        solve();
    }
    return 0;
}
